/**
 * 数据源管理 API
 */

import { get, post, put, del } from '@/utils/request'

/**
 * 获取数据源列表
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码
 * @param {number} params.size - 每页数量
 * @param {string} params.name - 数据源名称
 * @param {string} params.dbType - 数据库类型
 * @returns {Promise} 数据源列表数据
 */
export function getDataSourceList(params) {
  // 模拟数据
  return new Promise((resolve) => {
    setTimeout(() => {
      const mockData = [
        {
          id: 1,
          name: '主数据库-MySQL',
          dbType: 'mysql',
          host: 'localhost',
          port: 3306,
          database: 'big_erp',
          username: 'root',
          password: '******',
          charset: 'utf8mb4',
          params: 'useSSL=false&serverTimezone=Asia/Shanghai',
          status: 1,
          description: '主业务数据库',
          createTime: '2024-01-15 10:30:00',
          updateTime: '2024-01-15 10:30:00'
        },
        {
          id: 2,
          name: '数据仓库-PostgreSQL',
          dbType: 'postgresql',
          host: '192.168.1.100',
          port: 5432,
          database: 'datawarehouse',
          username: 'postgres',
          password: '******',
          charset: 'utf8',
          params: 'currentSchema=public',
          status: 1,
          description: '数据仓库，用于BI分析',
          createTime: '2024-01-16 14:20:00',
          updateTime: '2024-01-16 14:20:00'
        },
        {
          id: 3,
          name: '报表库-SQL Server',
          dbType: 'sqlserver',
          host: '192.168.1.101',
          port: 1433,
          database: 'ReportDB',
          username: 'sa',
          password: '******',
          charset: 'utf8',
          params: 'encrypt=false',
          status: 1,
          description: '专用报表数据库',
          createTime: '2024-01-17 09:00:00',
          updateTime: '2024-01-17 09:00:00'
        },
        {
          id: 4,
          name: '财务系统-Oracle',
          dbType: 'oracle',
          host: '192.168.1.102',
          port: 1521,
          database: 'ORCL',
          username: 'system',
          password: '******',
          charset: 'utf8',
          params: '',
          status: 1,
          description: '财务核心系统数据库',
          createTime: '2024-01-18 11:15:00',
          updateTime: '2024-01-18 11:15:00'
        },
        {
          id: 5,
          name: '国产库-达梦',
          dbType: 'dm',
          host: '192.168.1.103',
          port: 5236,
          database: 'DMDB',
          username: 'SYSDBA',
          password: '******',
          charset: 'utf8',
          params: '',
          status: 0,
          description: '达梦数据库测试环境',
          createTime: '2024-01-19 15:45:00',
          updateTime: '2024-01-19 15:45:00'
        }
      ]

      // 过滤数据
      let filteredData = mockData
      if (params.name) {
        filteredData = filteredData.filter(item => 
          item.name.includes(params.name)
        )
      }
      if (params.dbType) {
        filteredData = filteredData.filter(item => 
          item.dbType === params.dbType
        )
      }

      // 分页
      const start = (params.page - 1) * params.size
      const end = start + params.size
      const list = filteredData.slice(start, end)

      resolve({
        code: 200,
        message: 'success',
        data: {
          list,
          total: filteredData.length
        }
      })
    }, 500)
  })
}

/**
 * 获取数据源详情
 * @param {number|string} id - 数据源ID
 * @returns {Promise} 数据源详情数据
 */
export function getDataSourceDetail(id) {
  return get(`/api/datasource/${id}`)
}

/**
 * 新增数据源
 * @param {Object} data - 数据源数据
 * @param {string} data.name - 数据源名称
 * @param {string} data.dbType - 数据库类型
 * @param {string} data.host - 主机地址
 * @param {number} data.port - 端口
 * @param {string} data.database - 数据库名
 * @param {string} data.username - 用户名
 * @param {string} data.password - 密码
 * @param {string} data.charset - 字符编码
 * @param {string} data.params - 连接参数
 * @param {number} data.status - 状态
 * @param {string} data.description - 描述
 * @returns {Promise} 创建结果
 */
export function addDataSource(data) {
  // 模拟API调用
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('新增数据源:', data)
      resolve({
        code: 200,
        message: '新增成功',
        data: {
          id: Date.now(),
          ...data,
          createTime: new Date().toLocaleString('zh-CN', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit',
            second: '2-digit',
            hour12: false
          }).replace(/\//g, '-')
        }
      })
    }, 500)
  })
}

/**
 * 更新数据源
 * @param {number|string} id - 数据源ID
 * @param {Object} data - 数据源数据
 * @returns {Promise} 更新结果
 */
export function updateDataSource(id, data) {
  // 模拟API调用
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('更新数据源:', id, data)
      resolve({
        code: 200,
        message: '更新成功',
        data: {
          id,
          ...data,
          updateTime: new Date().toLocaleString('zh-CN', {
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit',
            second: '2-digit',
            hour12: false
          }).replace(/\//g, '-')
        }
      })
    }, 500)
  })
}

/**
 * 删除数据源
 * @param {number|string} id - 数据源ID
 * @returns {Promise} 删除结果
 */
export function deleteDataSource(id) {
  // 模拟API调用
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('删除数据源:', id)
      resolve({
        code: 200,
        message: '删除成功',
        data: null
      })
    }, 500)
  })
}

/**
 * 批量删除数据源
 * @param {Array<number|string>} ids - 数据源ID数组
 * @returns {Promise} 删除结果
 */
export function batchDeleteDataSource(ids) {
  return post('/api/datasource/batch-delete', { ids })
}

/**
 * 测试数据源连接
 * @param {number|string} id - 数据源ID
 * @returns {Promise} 测试结果
 */
export function testConnection(id) {
  // 模拟API调用
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // 模拟随机成功或失败
      const success = Math.random() > 0.2 // 80%成功率
      if (success) {
        console.log('测试连接成功:', id)
        resolve({
          code: 200,
          message: '连接成功',
          data: {
            connected: true,
            responseTime: Math.floor(Math.random() * 200) + 50,
            serverVersion: '8.0.32'
          }
        })
      } else {
        console.log('测试连接失败:', id)
        reject(new Error('连接失败：无法连接到数据库服务器'))
      }
    }, 1000)
  })
}

/**
 * 测试数据源连接（使用配置）
 * @param {Object} config - 数据源配置
 * @returns {Promise} 测试结果
 */
export function testConnectionByConfig(config) {
  return post('/api/datasource/test', config)
}

/**
 * 获取数据库表列表
 * @param {number|string} id - 数据源ID
 * @returns {Promise} 表列表
 */
export function getTableList(id) {
  return get(`/api/datasource/${id}/tables`)
}

/**
 * 获取表结构
 * @param {number|string} id - 数据源ID
 * @param {string} tableName - 表名
 * @returns {Promise} 表结构
 */
export function getTableStructure(id, tableName) {
  return get(`/api/datasource/${id}/tables/${tableName}/structure`)
}

/**
 * 执行SQL查询
 * @param {number|string} id - 数据源ID
 * @param {Object} data - 查询参数
 * @param {string} data.sql - SQL语句
 * @param {number} data.limit - 限制返回条数
 * @returns {Promise} 查询结果
 */
export function executeQuery(id, data) {
  return post(`/api/datasource/${id}/query`, data)
}

/**
 * 获取数据库统计信息
 * @param {number|string} id - 数据源ID
 * @returns {Promise} 统计信息
 */
export function getDataSourceStats(id) {
  return get(`/api/datasource/${id}/stats`)
}

/**
 * 同步数据源元数据
 * @param {number|string} id - 数据源ID
 * @returns {Promise} 同步结果
 */
export function syncMetadata(id) {
  return post(`/api/datasource/${id}/sync-metadata`)
}

export default {
  getDataSourceList,
  getDataSourceDetail,
  addDataSource,
  updateDataSource,
  deleteDataSource,
  batchDeleteDataSource,
  testConnection,
  testConnectionByConfig,
  getTableList,
  getTableStructure,
  executeQuery,
  getDataSourceStats,
  syncMetadata
}

